home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / urlparse.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  10KB  |  438 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __all__ = [
  5.     'urlparse',
  6.     'urlunparse',
  7.     'urljoin',
  8.     'urldefrag',
  9.     'urlsplit',
  10.     'urlunsplit']
  11. uses_relative = [
  12.     'ftp',
  13.     'http',
  14.     'gopher',
  15.     'nntp',
  16.     'imap',
  17.     'wais',
  18.     'file',
  19.     'https',
  20.     'shttp',
  21.     'mms',
  22.     'prospero',
  23.     'rtsp',
  24.     'rtspu',
  25.     '',
  26.     'sftp']
  27. uses_netloc = [
  28.     'ftp',
  29.     'http',
  30.     'gopher',
  31.     'nntp',
  32.     'telnet',
  33.     'imap',
  34.     'wais',
  35.     'file',
  36.     'mms',
  37.     'https',
  38.     'shttp',
  39.     'snews',
  40.     'prospero',
  41.     'rtsp',
  42.     'rtspu',
  43.     'rsync',
  44.     '',
  45.     'svn',
  46.     'svn+ssh',
  47.     'sftp']
  48. non_hierarchical = [
  49.     'gopher',
  50.     'hdl',
  51.     'mailto',
  52.     'news',
  53.     'telnet',
  54.     'wais',
  55.     'imap',
  56.     'snews',
  57.     'sip',
  58.     'sips']
  59. uses_params = [
  60.     'ftp',
  61.     'hdl',
  62.     'prospero',
  63.     'http',
  64.     'imap',
  65.     'https',
  66.     'shttp',
  67.     'rtsp',
  68.     'rtspu',
  69.     'sip',
  70.     'sips',
  71.     'mms',
  72.     '',
  73.     'sftp']
  74. uses_query = [
  75.     'http',
  76.     'wais',
  77.     'imap',
  78.     'https',
  79.     'shttp',
  80.     'mms',
  81.     'gopher',
  82.     'rtsp',
  83.     'rtspu',
  84.     'sip',
  85.     'sips',
  86.     '']
  87. uses_fragment = [
  88.     'ftp',
  89.     'hdl',
  90.     'http',
  91.     'gopher',
  92.     'news',
  93.     'nntp',
  94.     'wais',
  95.     'https',
  96.     'shttp',
  97.     'snews',
  98.     'file',
  99.     'prospero',
  100.     '']
  101. scheme_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.'
  102. MAX_CACHE_SIZE = 20
  103. _parse_cache = { }
  104.  
  105. def clear_cache():
  106.     global _parse_cache
  107.     _parse_cache = { }
  108.  
  109.  
  110. class BaseResult(tuple):
  111.     __slots__ = ()
  112.     
  113.     def scheme(self):
  114.         return self[0]
  115.  
  116.     scheme = property(scheme)
  117.     
  118.     def netloc(self):
  119.         return self[1]
  120.  
  121.     netloc = property(netloc)
  122.     
  123.     def path(self):
  124.         return self[2]
  125.  
  126.     path = property(path)
  127.     
  128.     def query(self):
  129.         return self[-2]
  130.  
  131.     query = property(query)
  132.     
  133.     def fragment(self):
  134.         return self[-1]
  135.  
  136.     fragment = property(fragment)
  137.     
  138.     def username(self):
  139.         netloc = self.netloc
  140.         if '@' in netloc:
  141.             userinfo = netloc.split('@', 1)[0]
  142.             if ':' in userinfo:
  143.                 userinfo = userinfo.split(':', 1)[0]
  144.             
  145.             return userinfo
  146.         
  147.  
  148.     username = property(username)
  149.     
  150.     def password(self):
  151.         netloc = self.netloc
  152.         if '@' in netloc:
  153.             userinfo = netloc.split('@', 1)[0]
  154.             if ':' in userinfo:
  155.                 return userinfo.split(':', 1)[1]
  156.             
  157.         
  158.  
  159.     password = property(password)
  160.     
  161.     def hostname(self):
  162.         netloc = self.netloc
  163.         if '@' in netloc:
  164.             netloc = netloc.split('@', 1)[1]
  165.         
  166.         if ':' in netloc:
  167.             netloc = netloc.split(':', 1)[0]
  168.         
  169.         if not netloc.lower():
  170.             pass
  171.  
  172.     hostname = property(hostname)
  173.     
  174.     def port(self):
  175.         netloc = self.netloc
  176.         if '@' in netloc:
  177.             netloc = netloc.split('@', 1)[1]
  178.         
  179.         if ':' in netloc:
  180.             port = netloc.split(':', 1)[1]
  181.             return int(port, 10)
  182.         
  183.  
  184.     port = property(port)
  185.  
  186.  
  187. class SplitResult(BaseResult):
  188.     __slots__ = ()
  189.     
  190.     def __new__(cls, scheme, netloc, path, query, fragment):
  191.         return BaseResult.__new__(cls, (scheme, netloc, path, query, fragment))
  192.  
  193.     
  194.     def geturl(self):
  195.         return urlunsplit(self)
  196.  
  197.  
  198.  
  199. class ParseResult(BaseResult):
  200.     __slots__ = ()
  201.     
  202.     def __new__(cls, scheme, netloc, path, params, query, fragment):
  203.         return BaseResult.__new__(cls, (scheme, netloc, path, params, query, fragment))
  204.  
  205.     
  206.     def params(self):
  207.         return self[3]
  208.  
  209.     params = property(params)
  210.     
  211.     def geturl(self):
  212.         return urlunparse(self)
  213.  
  214.  
  215.  
  216. def urlparse(url, scheme = '', allow_fragments = True):
  217.     tuple = urlsplit(url, scheme, allow_fragments)
  218.     (scheme, netloc, url, query, fragment) = tuple
  219.     if scheme in uses_params and ';' in url:
  220.         (url, params) = _splitparams(url)
  221.     else:
  222.         params = ''
  223.     return ParseResult(scheme, netloc, url, params, query, fragment)
  224.  
  225.  
  226. def _splitparams(url):
  227.     if '/' in url:
  228.         i = url.find(';', url.rfind('/'))
  229.         if i < 0:
  230.             return (url, '')
  231.         
  232.     else:
  233.         i = url.find(';')
  234.     return (url[:i], url[i + 1:])
  235.  
  236.  
  237. def _splitnetloc(url, start = 0):
  238.     delim = len(url)
  239.     for c in '/?#':
  240.         wdelim = url.find(c, start)
  241.         if wdelim >= 0:
  242.             delim = min(delim, wdelim)
  243.             continue
  244.     
  245.     return (url[start:delim], url[delim:])
  246.  
  247.  
  248. def urlsplit(url, scheme = '', allow_fragments = True):
  249.     allow_fragments = bool(allow_fragments)
  250.     key = (url, scheme, allow_fragments, type(url), type(scheme))
  251.     cached = _parse_cache.get(key, None)
  252.     if cached:
  253.         return cached
  254.     
  255.     if len(_parse_cache) >= MAX_CACHE_SIZE:
  256.         clear_cache()
  257.     
  258.     netloc = query = fragment = ''
  259.     i = url.find(':')
  260.     if i > 0:
  261.         if url[:i] == 'http':
  262.             scheme = url[:i].lower()
  263.             url = url[i + 1:]
  264.             if url[:2] == '//':
  265.                 (netloc, url) = _splitnetloc(url, 2)
  266.             
  267.             if allow_fragments and '#' in url:
  268.                 (url, fragment) = url.split('#', 1)
  269.             
  270.             if '?' in url:
  271.                 (url, query) = url.split('?', 1)
  272.             
  273.             v = SplitResult(scheme, netloc, url, query, fragment)
  274.             _parse_cache[key] = v
  275.             return v
  276.         
  277.         for c in url[:i]:
  278.             if c not in scheme_chars:
  279.                 break
  280.                 continue
  281.         else:
  282.             scheme = url[:i].lower()
  283.             url = url[i + 1:]
  284.     
  285.     if scheme in uses_netloc and url[:2] == '//':
  286.         (netloc, url) = _splitnetloc(url, 2)
  287.     
  288.     if allow_fragments and scheme in uses_fragment and '#' in url:
  289.         (url, fragment) = url.split('#', 1)
  290.     
  291.     if scheme in uses_query and '?' in url:
  292.         (url, query) = url.split('?', 1)
  293.     
  294.     v = SplitResult(scheme, netloc, url, query, fragment)
  295.     _parse_cache[key] = v
  296.     return v
  297.  
  298.  
  299. def urlunparse(.0):
  300.     (scheme, netloc, url, params, query, fragment) = .0
  301.     if params:
  302.         url = '%s;%s' % (url, params)
  303.     
  304.     return urlunsplit((scheme, netloc, url, query, fragment))
  305.  
  306.  
  307. def urlunsplit(.0):
  308.     (scheme, netloc, url, query, fragment) = .0
  309.     if (netloc or scheme) and scheme in uses_netloc and url[:2] != '//':
  310.         if url and url[:1] != '/':
  311.             url = '/' + url
  312.         
  313.         if not netloc:
  314.             pass
  315.         url = '//' + '' + url
  316.     
  317.     if scheme:
  318.         url = scheme + ':' + url
  319.     
  320.     if query:
  321.         url = url + '?' + query
  322.     
  323.     if fragment:
  324.         url = url + '#' + fragment
  325.     
  326.     return url
  327.  
  328.  
  329. def urljoin(base, url, allow_fragments = True):
  330.     if not base:
  331.         return url
  332.     
  333.     if not url:
  334.         return base
  335.     
  336.     (bscheme, bnetloc, bpath, bparams, bquery, bfragment) = urlparse(base, '', allow_fragments)
  337.     (scheme, netloc, path, params, query, fragment) = urlparse(url, bscheme, allow_fragments)
  338.     if scheme != bscheme or scheme not in uses_relative:
  339.         return url
  340.     
  341.     if scheme in uses_netloc:
  342.         if netloc:
  343.             return urlunparse((scheme, netloc, path, params, query, fragment))
  344.         
  345.         netloc = bnetloc
  346.     
  347.     if path[:1] == '/':
  348.         return urlunparse((scheme, netloc, path, params, query, fragment))
  349.     
  350.     if not path and params or query:
  351.         return urlunparse((scheme, netloc, bpath, bparams, bquery, fragment))
  352.     
  353.     segments = bpath.split('/')[:-1] + path.split('/')
  354.     if segments[-1] == '.':
  355.         segments[-1] = ''
  356.     
  357.     while '.' in segments:
  358.         segments.remove('.')
  359.     while None:
  360.         i = 1
  361.         n = len(segments) - 1
  362.         while i < n:
  363.             if segments[i] == '..' and segments[i - 1] not in ('', '..'):
  364.                 del segments[i - 1:i + 1]
  365.                 break
  366.             
  367.             i = i + 1
  368.         break
  369.         continue
  370.         if segments == [
  371.             '',
  372.             '..']:
  373.             segments[-1] = ''
  374.         elif len(segments) >= 2 and segments[-1] == '..':
  375.             segments[-2:] = [
  376.                 '']
  377.         
  378.     return urlunparse((scheme, netloc, '/'.join(segments), params, query, fragment))
  379.  
  380.  
  381. def urldefrag(url):
  382.     if '#' in url:
  383.         (s, n, p, a, q, frag) = urlparse(url)
  384.         defrag = urlunparse((s, n, p, a, q, ''))
  385.         return (defrag, frag)
  386.     else:
  387.         return (url, '')
  388.  
  389. test_input = '\n      http://a/b/c/d\n\n      g:h        = <URL:g:h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      g          = <URL:http://a/b/c/g>\n      ./g        = <URL:http://a/b/c/g>\n      g/         = <URL:http://a/b/c/g/>\n      /g         = <URL:http://a/g>\n      //g        = <URL:http://g>\n      ?y         = <URL:http://a/b/c/d?y>\n      g?y        = <URL:http://a/b/c/g?y>\n      g?y/./x    = <URL:http://a/b/c/g?y/./x>\n      .          = <URL:http://a/b/c/>\n      ./         = <URL:http://a/b/c/>\n      ..         = <URL:http://a/b/>\n      ../        = <URL:http://a/b/>\n      ../g       = <URL:http://a/b/g>\n      ../..      = <URL:http://a/>\n      ../../g    = <URL:http://a/g>\n      ../../../g = <URL:http://a/../g>\n      ./../g     = <URL:http://a/b/g>\n      ./g/.      = <URL:http://a/b/c/g/>\n      /./g       = <URL:http://a/./g>\n      g/./h      = <URL:http://a/b/c/g/h>\n      g/../h     = <URL:http://a/b/c/h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      http:?y         = <URL:http://a/b/c/d?y>\n      http:g?y        = <URL:http://a/b/c/g?y>\n      http:g?y/./x    = <URL:http://a/b/c/g?y/./x>\n'
  390.  
  391. def test():
  392.     import sys as sys
  393.     base = ''
  394.     if sys.argv[1:]:
  395.         fn = sys.argv[1]
  396.         if fn == '-':
  397.             fp = sys.stdin
  398.         else:
  399.             fp = open(fn)
  400.     else:
  401.         
  402.         try:
  403.             StringIO = StringIO
  404.             import cStringIO
  405.         except ImportError:
  406.             StringIO = StringIO
  407.             import StringIO
  408.  
  409.         fp = StringIO(test_input)
  410.     while None:
  411.         line = fp.readline()
  412.         if not line:
  413.             break
  414.         
  415.         words = line.split()
  416.         if not words:
  417.             continue
  418.         
  419.         url = words[0]
  420.         parts = urlparse(url)
  421.         print '%-10s : %s' % (url, parts)
  422.         abs = urljoin(base, url)
  423.         if not base:
  424.             base = abs
  425.         
  426.         wrapped = '<URL:%s>' % abs
  427.         print '%-10s = %s' % (url, wrapped)
  428.         if len(words) == 3 and words[1] == '=':
  429.             if wrapped != words[2]:
  430.                 print 'EXPECTED', words[2], '!!!!!!!!!!'
  431.             
  432.         continue
  433.         return None
  434.  
  435. if __name__ == '__main__':
  436.     test()
  437.  
  438.